/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.qsdm.es.dao;

import com.qsdm.es.dao.exceptions.NonexistentEntityException;
import com.qsdm.es.dao.exceptions.PreexistingEntityException;
import com.qsdm.es.persistence.Calendariocurso;
import com.qsdm.es.persistence.CalendariocursoPK;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import com.qsdm.es.persistence.Curso;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.transaction.UserTransaction;

/**
 *
 * @author alberto
 */
public class CalendariocursoJpaController extends BasicJpaController {

    public void create(Calendariocurso calendariocurso) throws PreexistingEntityException, Exception {
        if (calendariocurso.getCalendariocursoPK() == null) {
            calendariocurso.setCalendariocursoPK(new CalendariocursoPK());
        }
        calendariocurso.getCalendariocursoPK().setCursoid(calendariocurso.getCurso().getId());
        EntityManager em = null;
        try {
            em = getEntityManager();
            
            Curso curso = calendariocurso.getCurso();
            if (curso != null) {
                curso = em.getReference(curso.getClass(), curso.getId());
                calendariocurso.setCurso(curso);
            }
            em.persist(calendariocurso);
            if (curso != null) {
                curso.getCalendariocursoList().add(calendariocurso);
                curso = em.merge(curso);
            }
            
        } catch (Exception ex) {
            if (findCalendariocurso(calendariocurso.getCalendariocursoPK()) != null) {
                throw new PreexistingEntityException("Calendariocurso " + calendariocurso + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Calendariocurso calendariocurso) throws NonexistentEntityException, Exception {
        calendariocurso.getCalendariocursoPK().setCursoid(calendariocurso.getCurso().getId());
        EntityManager em = null;
        try {
            em = getEntityManager();
            
            Calendariocurso persistentCalendariocurso = em.find(Calendariocurso.class, calendariocurso.getCalendariocursoPK());
            Curso cursoOld = persistentCalendariocurso.getCurso();
            Curso cursoNew = calendariocurso.getCurso();
            if (cursoNew != null) {
                cursoNew = em.getReference(cursoNew.getClass(), cursoNew.getId());
                calendariocurso.setCurso(cursoNew);
            }
            calendariocurso = em.merge(calendariocurso);
            if (cursoOld != null && !cursoOld.equals(cursoNew)) {
                cursoOld.getCalendariocursoList().remove(calendariocurso);
                cursoOld = em.merge(cursoOld);
            }
            if (cursoNew != null && !cursoNew.equals(cursoOld)) {
                cursoNew.getCalendariocursoList().add(calendariocurso);
                cursoNew = em.merge(cursoNew);
            }
            
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                CalendariocursoPK id = calendariocurso.getCalendariocursoPK();
                if (findCalendariocurso(id) == null) {
                    throw new NonexistentEntityException("The calendariocurso with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(CalendariocursoPK id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            
            Calendariocurso calendariocurso;
            try {
                calendariocurso = em.getReference(Calendariocurso.class, id);
                calendariocurso.getCalendariocursoPK();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The calendariocurso with id " + id + " no longer exists.", enfe);
            }
            Curso curso = calendariocurso.getCurso();
            if (curso != null) {
                curso.getCalendariocursoList().remove(calendariocurso);
                curso = em.merge(curso);
            }
            em.remove(calendariocurso);
            
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Calendariocurso> findCalendariocursoEntities() {
        return findCalendariocursoEntities(true, -1, -1);
    }

    public List<Calendariocurso> findCalendariocursoEntities(int maxResults, int firstResult) {
        return findCalendariocursoEntities(false, maxResults, firstResult);
    }

    private List<Calendariocurso> findCalendariocursoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Calendariocurso.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Calendariocurso findCalendariocurso(CalendariocursoPK id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Calendariocurso.class, id);
        } finally {
            em.close();
        }
    }

    public int getCalendariocursoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Calendariocurso> rt = cq.from(Calendariocurso.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
